package cn.rmc.hrm.service.impl;

import cn.rmc.hrm.constants.BaseConstant;
import cn.rmc.hrm.domain.CourseType;
import cn.rmc.hrm.mapper.CourseTypeMapper;
import cn.rmc.hrm.service.ICourseTypeService;
import cn.rmc.hrm.util.AssertUtils;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import vo.CrumbsVo;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * <p>
 * 课程目录 服务实现类
 * </p>
 *
 * @author whale.chen
 * @since 2021-08-19
 */
@Service
public class CourseTypeServiceImpl extends ServiceImpl<CourseTypeMapper, CourseType> implements ICourseTypeService {
    @Autowired
    private RedisTemplate<Object,Object> redisTemplate;
    public List<CourseType> loadCourseTypeFromDbOrRedis(){
//        从redis中查询课程分类数据
        Object result = redisTemplate.opsForValue().get(BaseConstant.RedisConstant.ALL_COURSE_TYPES);
//        如果redis中有数据
        if (result!=null){
            return (List<CourseType>) result;
        }
//        没有数据就从数据库里拿
        List<CourseType> courseTypes = super.selectList(null);
//        将数据存入redis
        redisTemplate.opsForValue().set(BaseConstant.RedisConstant.ALL_COURSE_TYPES,courseTypes);
//        返回查询数据
        return courseTypes;
    }

    /**
     * 新增
     * @param entity
     * @return
     */
    @Override
    public boolean insert(CourseType entity) {
        boolean flag = super.insert(entity);
        if (flag){
//            清除redis
            redisTemplate.delete(BaseConstant.RedisConstant.ALL_COURSE_TYPES);
        }
        return flag;
    }

    /**
     * 删除
     * @param id
     * @return
     */
    @Override
    public boolean deleteById(Serializable id) {
        boolean flag = super.deleteById(id);
        if (flag){
//            清除redis
            redisTemplate.delete(BaseConstant.RedisConstant.ALL_COURSE_TYPES);
        }
        return flag;
    }

    /**
     * 更新
     * @param entity
     * @return
     */
    @Override
    public boolean updateById(CourseType entity) {
        boolean flag = super.updateById(entity);
        if (flag){
//            清除redis
            redisTemplate.delete(BaseConstant.RedisConstant.ALL_COURSE_TYPES);
        }
        return flag;
    }

    @Override
    public List<CourseType> treeData() {
//        查询所有类型数据
        List<CourseType> courseTypes = loadCourseTypeFromDbOrRedis();
//        将数据装入map
//        Map<Long,CourseType> map = courseTypes.stream().collect(Collectors.toMap(CourseType::getId,courseType -> courseType));
        Map<Long,CourseType> map = new HashMap<>();
        for (CourseType courseType : courseTypes) {
            map.put(courseType.getId(),courseType);
        }
//        找到最顶层
        List<CourseType> fristCourseType = new ArrayList<CourseType>();
        for (CourseType courseType : courseTypes) {
//            如果pid为null或者为0，则为最顶层
            if (courseType.getPid()==null || courseType.getPid().intValue()==0){
//                存入最顶层数据
                fristCourseType.add(courseType);
            }else {
//               将自己放入父级
                CourseType parenttype = map.get(courseType.getPid());
                if (parenttype!=null)
//                    放入子级
                    parenttype.getChildren().add(courseType);
            }
        }
        return fristCourseType;

    }

    @Override
    public List<CrumbsVo> crumbs(Long courseTypeId) {
//        判断数据是否为空
        AssertUtils.isNull(courseTypeId,"参数不能为空");
//        根据id查询自己
        CourseType courseType = super.selectById(courseTypeId);
//        查询数据是否为空
        AssertUtils.isNull(courseType,"没有该数据");
//        根据path拿到数据（通过split）
        String[] paths =  courseType.getPath().split("\\.");
        List<CrumbsVo> Vos = new ArrayList<>(paths.length);
        for (String path : paths) {
            CrumbsVo crumbsVos  = new CrumbsVo();
            CourseType type = super.selectById(Long.valueOf(path));
            crumbsVos.setOwnerProductType(type);
//            根据第一级的pid，查询所有同济的数据
            if (type.getPid()!= null && type.getPid()!=0){
                EntityWrapper<CourseType> wrapper = new EntityWrapper<>();
//                比较值
                wrapper.eq("pid",type.getPid());
                List<CourseType> courseTypes = baseMapper.selectList(wrapper);
//                移除自己
                courseTypes.remove(type);
                crumbsVos.setOtherProductTypes(courseTypes);
            }
            Vos.add(crumbsVos);
        }
        return Vos;
    }
}
